home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Tcl-Tk 8.0 / Pre-installed version / tcl8.0 / tests / winPipe.test < prev   
Encoding:
Text File  |  1997-08-15  |  10.0 KB  |  290 lines  |  [TEXT/ALFA]
  1. # 
  2. # winPipe.test --
  3. #
  4. # This file contains a collection of tests for tclWinPipe.c
  5.  
  6. # Sourcing this file into Tcl runs the tests and generates output for 
  7. # errors.  No output means no errors were found.
  8. #
  9. # Copyright (c) 1996 Sun Microsystems, Inc.
  10. #
  11. # See the file "license.terms" for information on usage and redistribution
  12. # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  13. #
  14. # SCCS: @(#) winPipe.test 1.9 97/08/05 11:44:28
  15.  
  16. if {$tcl_platform(platform) != "windows"} {
  17.     return
  18. }
  19.  
  20. set cat16 [file join $tcl_library ../win/cat16.exe]
  21. set cat32 [file join $tcl_library ../win/cat32.exe]
  22.  
  23. if {[string compare test [info procs test]] == 1} then {source defs}
  24.  
  25. if [catch {puts console1 ""}] {
  26.     set testConfig(AllocConsole) 1
  27. } else {
  28.     set testConfig(.console) 1
  29. }
  30.  
  31. set big aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n
  32. append big $big
  33. append big $big    
  34. append big $big
  35. append big $big
  36. append big $big
  37. append big $big
  38.  
  39. set f [open "little" w] 
  40. puts -nonewline $f "little"
  41. close $f
  42.  
  43. set f [open "big" w]
  44. puts -nonewline $f $big
  45. close $f
  46.  
  47. proc contents {file} {
  48.     set f [open $file r]
  49.     set r [read $f]
  50.     close $f
  51.     set r
  52. }
  53.  
  54. if {$testConfig(stdio) && [file exists $cat32]} {
  55. test winpipe-1.1 {32 bit comprehensive tests: from little file} {
  56.     exec $cat32 < little > stdout 2> stderr
  57.     list [contents stdout] [contents stderr]
  58. } "little stderr32"
  59. test winpipe-1.2 {32 bit comprehensive tests: from big file} {
  60.     exec $cat32 < big > stdout 2> stderr
  61.     list [contents stdout] [contents stderr]
  62. } "{$big} stderr32"
  63. test winpipe-1.3 {32 bit comprehensive tests: a little from pipe} {nt} {
  64.     exec more < little | $cat32 > stdout 2> stderr
  65.     list [contents stdout] [contents stderr]
  66. } "{little\n} stderr32"
  67. test winpipe-1.4 {32 bit comprehensive tests: a little from pipe} {95} {
  68.     exec more < little |& $cat32 > stdout 2> stderr
  69.     list [contents stdout] [contents stderr]
  70. } "{\nlittle} stderr32"
  71. test winpipe-1.5 {32 bit comprehensive tests: a lot from pipe} {nt} {
  72.     exec more < big | $cat32 > stdout 2> stderr
  73.     list [contents stdout] [contents stderr]
  74. } "{$big} stderr32"
  75. test winpipe-1.6 {32 bit comprehensive tests: a lot from pipe} {95} {
  76.     exec command /c type big |& $cat32 > stdout 2> stderr
  77.     list [contents stdout] [contents stderr]
  78. } "{$big} stderr32"
  79. test winpipe-1.7 {32 bit comprehensive tests: from console} {AllocConsole} {
  80.     # would block waiting for human input
  81. } {}
  82. test winpipe-1.8 {32 bit comprehensive tests: from NUL} {
  83.     exec $cat32 < nul > stdout 2> stderr
  84.     list [contents stdout] [contents stderr]
  85. } "{} stderr32"
  86. test winpipe-1.9 {32 bit comprehensive tests: from socket} {
  87.     # doesn't work
  88. } {}
  89. test winpipe-1.10 {32 bit comprehensive tests: from nowhere} {.console} {
  90.     exec $cat32 > stdout 2> stderr
  91.     list [contents stdout] [contents stderr]
  92. } "{} stderr32"
  93. test winpipe-1.11 {32 bit comprehensive tests: from file handle} {
  94.     set f [open "little" r]
  95.     exec $cat32 <@$f > stdout 2> stderr
  96.     close $f
  97.     list [contents stdout] [contents stderr]
  98. } "little stderr32"
  99. test winpipe-1.12 {32 bit comprehensive tests: read from application} {
  100.     set f [open "|$cat32 < little" r]
  101.     gets $f line
  102.     catch {close $f} msg
  103.     list $line $msg
  104. } "little stderr32"
  105. test winpipe-1.13 {32 bit comprehensive tests: a little to file} {
  106.     exec $cat32 < little > stdout 2> stderr
  107.     list [contents stdout] [contents stderr]
  108. } "little stderr32"
  109. test winpipe-1.14 {32 bit comprehensive tests: a lot to file} {
  110.     exec $cat32 < big > stdout 2> stderr
  111.     list [contents stdout] [contents stderr]
  112. } "{$big} stderr32"
  113. test winpipe-1.15 {32 bit comprehensive tests: a little to pipe} {nt} {
  114.     exec $cat32 < little | more > stdout 2> stderr
  115.     list [contents stdout] [contents stderr]
  116. } "{little\n} stderr32"
  117. test winpipe-1.16 {32 bit comprehensive tests: a little to pipe} {95} {
  118.     exec $cat32 < little | more > stdout 2> stderr
  119.     list [contents stdout] [contents stderr]
  120. } "{\nlittle} stderr32"
  121. test winpipe-1.17 {32 bit comprehensive tests: a lot to pipe} {nt} {
  122.     exec $cat32 < big | more > stdout 2> stderr
  123.     list [contents stdout] [contents stderr]
  124. } "{$big\n} stderr32"
  125. test winpipe-1.18 {32 bit comprehensive tests: a lot to pipe} {95} {
  126.     exec $cat32 < big | more > stdout 2> stderr
  127.     list [contents stdout] [contents stderr]
  128. } "{\n$big} stderr32"
  129. test winpipe-1.19 {32 bit comprehensive tests: to console} {
  130.     catch {exec $cat32 << "You should see this\n" >@stdout} msg
  131.     set msg
  132. } stderr32
  133. test winpipe-1.20 {32 bit comprehensive tests: to NUL} {
  134.     # some apps hang when sending a large amount to NUL.  $cat32 isn't one.
  135.     catch {exec $cat32 < big > nul} msg
  136.     set msg
  137. } stderr32
  138. test winpipe-1.21 {32 bit comprehensive tests: to nowhere} {.console} {
  139.     exec $cat32 < big >&@stdout 
  140. } {}
  141. test winpipe-1.22 {32 bit comprehensive tests: to file handle} {
  142.     set f1 [open "stdout" w]
  143.     set f2 [open "stderr" w]
  144.     exec $cat32 < little >@$f1 2>@$f2
  145.     close $f1
  146.     close $f2
  147.     list [contents stdout] [contents stderr]
  148. } "little stderr32"
  149. test winpipe-1.23 {32 bit comprehensive tests: write to application} {
  150.     set f [open "|$cat32 > stdout" w]
  151.     puts -nonewline $f "foo"
  152.     catch {close $f} msg
  153.     list [contents stdout] $msg
  154. } "foo stderr32"
  155. test winpipe-1.24 {32 bit comprehensive tests: read/write application} {
  156.     set f [open "|$cat32" r+]
  157.     puts $f $big
  158.     puts $f \032
  159.     flush $f
  160.     set r [read $f 64]
  161.     catch {close $f}
  162.     set r
  163. } "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  164. test winpipe-1.25 {32 bit comprehensive tests: to socket} {
  165.     # doesn't work
  166. } {}
  167. }
  168.  
  169. set stderr16 "stderr16"
  170. if {$tcl_platform(os) == "Win32s"} {
  171.     set stderr16 "{}"
  172. }
  173. if [file exists $cat16] {
  174. test winpipe-2.1 {16 bit comprehensive tests: from little file} {
  175.     exec $cat16 < little > stdout 2> stderr
  176.     list [contents stdout] [contents stderr]
  177. } "little $stderr16"
  178. test winpipe-2.2 {16 bit comprehensive tests: from big file} {
  179.     exec $cat16 < big > stdout 2> stderr
  180.     list [contents stdout] [contents stderr] 
  181. } "{$big} $stderr16"
  182. test winpipe-2.3 {16 bit comprehensive tests: a little from pipe} {nt} {
  183.     exec more < little | $cat16 > stdout 2> stderr
  184.     list [contents stdout] [contents stderr]
  185. } "{little\n} stderr16"
  186. test winpipe-2.4 {16 bit comprehensive tests: a little from pipe} {95} {
  187.     exec more < little | $cat16 > stdout 2> stderr
  188.     list [contents stdout] [contents stderr]
  189. } "{\nlittle} stderr16"
  190. test winpipe-2.5 {16 bit comprehensive tests: a lot from pipe} {nt} {
  191.     exec $cat16 < big | $cat16 > stdout 2> stderr
  192.     list [contents stdout] [contents stderr] 
  193. } "{$big} stderr16stderr16"
  194. test winpipe-2.6 {16 bit comprehensive tests: a lot from pipe} {95} {
  195.     exec more < big | $cat16 > stdout 2> stderr
  196.     list [contents stdout] [contents stderr] 
  197. } "{\n$big} stderr16"
  198. test winpipe-2.7 {16 bit comprehensive tests: from console} {AllocConsole} {
  199.     # would block waiting for human input
  200. } {}             
  201. test winpipe-2.8 {16 bit comprehensive tests: from NUL} {nt} {
  202.     exec $cat16 < nul > stdout 2> stderr
  203.     list [contents stdout] [contents stderr]
  204. } "{} stderr16"
  205. test winpipe-2.9 {16 bit comprehensive tests: from socket} {
  206.     # doesn't work
  207. } {}
  208. test winpipe-2.10 {16 bit comprehensive tests: from nowhere} {.console} {
  209.     exec $cat16 > stdout 2> stderr
  210.     list [contents stdout] [contents stderr]
  211. } "{} stderr16"
  212. test winpipe-2.11 {16 bit comprehensive tests: from file handle} {
  213.     set f [open "little" r]
  214.     exec $cat16 <@$f > stdout 2> stderr
  215.     close $f
  216.     list [contents stdout] [contents stderr]
  217. } "little $stderr16"
  218. test winpipe-2.12 {16 bit comprehensive tests: read from application} {
  219.     set f [open "|$cat16 < little" r]
  220.     gets $f line
  221.     catch {close $f} msg
  222.     list $line $msg
  223. } "little $stderr16"
  224. test winpipe-2.13 {16 bit comprehensive tests: a little to file} {
  225.     exec $cat16 < little > stdout 2> stderr
  226.     list [contents stdout] [contents stderr]
  227. } "little $stderr16"
  228. test winpipe-2.14 {16 bit comprehensive tests: a lot to file} {
  229.     exec $cat16 < big > stdout 2> stderr
  230.     list [contents stdout] [contents stderr]
  231. } "{$big} $stderr16"
  232. test winpipe-2.15 {16 bit comprehensive tests: a little to pipe} {nt} {
  233.     catch {exec $cat16 < little | more > stdout 2> stderr}
  234.     list [contents stdout] [contents stderr]
  235. } "{little\n} stderr16"
  236. test winpipe-2.16 {16 bit comprehensive tests: a little to pipe} {95} {
  237.     exec $cat16 < little | more > stdout 2> stderr
  238.     list [contents stdout] [contents stderr]
  239. } "{\nlittle} stderr16"
  240. test winpipe-2.17 {16 bit comprehensive tests: a lot to pipe} {nt} {
  241.     catch {exec $cat16 < big | more > stdout 2> stderr}
  242.     list [contents stdout] [contents stderr]
  243. } "{$big\n} stderr16"
  244. test winpipe-2.18 {16 bit comprehensive tests: a lot to pipe} {95} {
  245.     exec $cat16 < big | more > stdout 2> stderr
  246.     list [contents stdout] [contents stderr]
  247. } "{\n$big} stderr16"
  248. test winpipe-2.19 {16 bit comprehensive tests: to console} {
  249.     catch {exec $cat16 << "You should see this\n" >@stdout} msg
  250.     set msg
  251. } [lindex $stderr16 0]
  252. test winpipe-2.20 {16 bit comprehensive tests: to NUL} {nt} {
  253.     # some apps hang when sending a large amount to NUL.  cat16 isn't one.
  254.     catch {exec $cat16 < big > nul} msg
  255.     set msg
  256. } stderr16
  257. test winpipe-2.21 {16 bit comprehensive tests: to nowhere} {.console} {
  258.     exec $cat16 < big >&@stdout 
  259. } {}
  260. test winpipe-2.22 {16 bit comprehensive tests: to file handle} {
  261.     set f1 [open "stdout" w]
  262.     set f2 [open "stderr" w]
  263.     exec $cat16 < little >@$f1 2>@$f2
  264.     close $f1
  265.     close $f2
  266.     list [contents stdout] [contents stderr]
  267. } "little $stderr16"
  268. test winpipe-2.23 {16 bit comprehensive tests: write to application} {!win32s} {
  269.     set f [open "|$cat16 > stdout" w]
  270.     puts -nonewline $f "foo"
  271.     catch {close $f} msg
  272.     list [contents stdout] $msg
  273. } "foo stderr16"
  274. test winpipe-2.24 {16 bit comprehensive tests: read/write application} {nt} {
  275.     set f [open "|$cat16" r+]
  276.     puts $f $big
  277.     puts $f \032
  278.     flush $f
  279.     set r [read $f 64]
  280.     catch {close $f}
  281.     set r
  282. } "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  283. test winpipe-2.25 {16 bit comprehensive tests: to socket} {
  284.     # doesn't work
  285. } {}
  286. }
  287.  
  288. file delete big little
  289.  
  290.